package com.ling.zookeeper.zookeeperUtil;

import java.io.IOException;
import java.util.List;
import java.util.concurrent.CountDownLatch;

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.Watcher.Event.KeeperState;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
 *  
 * @author yueling
 *
 */
public class BaseZookeeper implements Watcher
{
	private final static Logger logger = LoggerFactory.getLogger(BaseZookeeper.class);
    public ZooKeeper zooKeeper;
 
    private static final int SESSION_TIME_OUT = 2000;
 
    private CountDownLatch countDownLatch = new CountDownLatch(1);
 
    /**
     * 连接zookeeper
     * 
     * @param host
     * @throws IOException
     * @throws InterruptedException
     */
    public void connectZookeeper(String host) throws IOException,
            InterruptedException
    {
        zooKeeper = new ZooKeeper(host, SESSION_TIME_OUT, this);
        countDownLatch.await();
        logger.info("--------connect zookeeper success-----------");
 
    }
 
    /**
     * 实现watcher的接口方法，当连接zookeeper成功后，zookeeper会通过此方法通知watcher<br>
     * 此处为如果接受到连接成功的event，则countDown，让当前线程继续其他事情。
     */
    @Override
    public void process(WatchedEvent event)
    {
        if (event.getState() == KeeperState.SyncConnected)
        {
            logger.info("--------watcher received event-----------");
            countDownLatch.countDown();
        }
    }
 
   
    /**
     * 根据路径创建节点，并且设置节点数据
     * @param path
     * @param data
     * @return
     * @throws KeeperException
     * @throws InterruptedException
     */
    public String createNode(String path, byte[] data) throws KeeperException,
            InterruptedException
    {
    	
        return this.zooKeeper.create(path, data, Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT);
    }
    /**
     * 根据路径创建节点，并且设置节点数据
     * @param path
     * @param data
     * @return
     * @throws KeeperException
     * @throws InterruptedException
     */
    public String create(String path, byte[] data) throws KeeperException,InterruptedException
    {
    	try {  
            /*List<String> nodes = zooKeeper.getChildren(groupName, false);  
            for (String node : nodes) {  
            	delete(groupName + "/" + node);  
            }  
            
            zooKeeper.create(groupName, -1);  
            logger.info("delete {}",groupName);*/
        } catch (Exception e) {  
            e.printStackTrace();  
        }
        return this.zooKeeper.create(path, data, Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT);
    }
    /**
     * 根据路径获取所有孩子节点
     * 
     * @param path
     * @return
     * @throws KeeperException
     * @throws InterruptedException
     */
    public List<String> getChildren(String path) throws KeeperException,
            InterruptedException
    {
        return this.zooKeeper.getChildren(path, false);
    }
 
    public Stat setData(String path, byte [] data, int version) throws KeeperException, InterruptedException
    {
        return this.zooKeeper.setData(path, data, version);
    }
     
    /**
     * 根据路径获取节点数据
     * 
     * @param path
     * @return
     * @throws KeeperException
     * @throws InterruptedException
     */
    public byte[] getData(String path) throws KeeperException,
            InterruptedException
    {
        return this.zooKeeper.getData(path, false, null);
    }
 
    /**
     * 删除节点
     * 
     * @param path
     * @param version
     * @throws InterruptedException
     * @throws KeeperException
     */
    public void deletNode(String path, int version)
            throws InterruptedException, KeeperException
    {
        this.zooKeeper.delete(path, version);
    }
    /**
     * 删除节点(递归)
     * 
     * @param path
     * @param version
     * @throws InterruptedException
     * @throws KeeperException
     */
    public void delete(String groupName) throws Exception {  
        //String path = "/" + groupName;  
        try {  
            List<String> nodes = zooKeeper.getChildren(groupName, false);  
            for (String node : nodes) {  
            	delete(groupName + "/" + node);  
            }  
            
            zooKeeper.delete(groupName, -1);  
            logger.info("delete {}",groupName);
        } catch (Exception e) {  
            e.printStackTrace();  
        }
    }  
    /**
     * 关闭zookeeper连接
     * 
     * @throws InterruptedException
     */
    public void closeConnect() throws InterruptedException
    {
        if (null != zooKeeper)
        {
            zooKeeper.close();
        }
    }
 
}
